home *** CD-ROM | disk | FTP | other *** search
/ Mixa 155: Dogs / MIXA 155: Dogs.iso / pc / Viewer / BROWSER(W) / フィルタ / PDF / LIB / gs_cff.ps < prev    next >
Encoding:
Text File  |  2002-10-29  |  20.8 KB  |  739 lines
  1. %    Copyright (C) 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile: gs_cff.ps,v $ $Revision: 1.10 $
  7. % Loader for CFF (compressed) fonts, including OpenType CFFs.
  8. % The following are not implemented yet:
  9. %    Deleted entries in the Name Index
  10. %    Embedded PostScript
  11. %    Multiple Master fonts
  12. %    Chameleon fonts
  13. %    Synthetic fonts
  14.  
  15. % ---------------- Font loading machinery ---------------- %
  16.  
  17. % Augment the FONTPATH machinery so it recognizes OpenType CFF font sets.
  18.  
  19. /.scanfontheaders where {
  20.   pop /.scanfontheaders [
  21.    .scanfontheaders aload pop (OTTO*)
  22.   ] def
  23. } if
  24.  
  25. % Load a font file that might be an OpenType CFF font set.
  26.  
  27. % <file> .loadfontfile -
  28. /.loadnonottofontfile /.loadfontfile load def
  29. /.loadfontfile {
  30.   dup 4 string .peekstring pop (OTTO) eq {
  31.         % If this is a font at all, it's an OpenType CFF font set.
  32.     .loadottofontfile
  33.   } {
  34.         % Not a TrueType font.
  35.     .loadnonottofontfile
  36.   } ifelse
  37. } bind def
  38.  
  39. % <file> .loadottofontfile -
  40. /.loadottofontfile {
  41.   /FontSetInit /ProcSet findresource begin
  42.   2 dict begin
  43.   /f exch def /cff null def
  44.   card32 pop card16 6 { next pop } repeat dup {
  45.         % Stack: numtables tablesleft
  46.     dup 0 eq {
  47.       pop pop /.loadottofontfile cvx /invalidfont signalerror
  48.     } if
  49.     f 4 string readstring pop (CFF ) eq { sub exit } if
  50.     1 sub
  51.   } loop
  52.         % Stack: tablesread
  53.   card32 pop card32 card32
  54.         % Stack: tablesread start length
  55.   exch 3 -1 roll 1 add 16 mul 12 add sub
  56.   f exch subfilefilter flushfile    % skip to start
  57.   f exch subfilefilter end
  58.     % Use a random FontSet resource name.  ****** WRONG ******
  59.   realtime rand xor =string cvs exch false
  60.   ReadData
  61. } bind def
  62.  
  63. 30 dict begin
  64.  
  65. % ---------------- Standard strings (actually names) ---------------- %
  66.  
  67. /StandardStrings mark
  68.     % The initial StandardStrings that that denote characters are
  69.     % defined as a pseudo-Encoding.
  70. % 0
  71.   /CFFStandardStrings .findencoding aload pop
  72. % 379
  73.   (001.000)
  74. % 380
  75.   (001.001) (001.002) (001.003) /Black /Bold
  76.   /Book /Light /Medium /Regular /Roman
  77.   /Semibold
  78. .packtomark def
  79.  
  80. % ---------------- Standard encodings ---------------- %
  81.  
  82. /StandardEncodings [
  83.  
  84. % StandardEncoding
  85. mark
  86.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  87.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  88.   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  89.   17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
  90.   33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
  91.   49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
  92.   65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
  93.   81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 0
  94.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  95.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  96.   0 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
  97.   0 111 112 113 114 0 115 116 117 118 119 120 121 122 0 123
  98.   0 124 125 126 127 128 129 130 131 0 132 133 0 134 135 136
  99.   137 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  100.   0 138 0 139 0 0 0 0 140 141 142 143 0 0 0 0
  101.   0 144 0 0 0 145 0 0 146 147 148 149 0 0 0 0
  102. .packtomark
  103.  
  104. % ExpertEncoding
  105. mark
  106.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  107.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  108.   1 229 230 0 231 232 233 234 235 236 237 238 13 14 15 99
  109.   239 240 241 242 243 244 245 246 247 248 27 28 249 250 251 252
  110.   0 253 254 255 256 257 0 0 0 258 0 0 259 260 261 262
  111.   0 0 263 264 265 0 266 109 110 267 268 269 0 270 271 272
  112.   273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
  113.   289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 0
  114.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  115.   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  116.   0 304 305 306 0 0 307 308 309 310 311 0 312 0 0 313
  117.   0 0 314 315 0 0 316 317 318 0 0 0 158 155 163 319
  118.   320 321 322 323 324 325 0 0 326 150 164 169 327 328 329 330
  119.   331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
  120.   347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
  121.   363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
  122. .packtomark
  123.  
  124. ] readonly def
  125.  
  126. % ---------------- Standard Charsets ---------------- %
  127.  
  128. % We include an explicit 0 at the beginning of each charset.
  129.  
  130. /StandardCharsets [
  131.  
  132. % ISOAdobe
  133. mark
  134.   0
  135.   1 1 228 { } for
  136. .packtomark
  137.  
  138. % Expert
  139. mark
  140.   0
  141.   1 229 230 231 232 233 234 235 236 237 238 13 14 15 99 239
  142.   240 241 242 243 244 245 246 247 248 27 28 249 250 251 252 253
  143.   254 255 256 257 258 259 260 261 262 263 264 265 266 109 110 267
  144.   268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
  145.   284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
  146.   300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
  147.   316 317 318 158 155 163 319 320 321 322 323 324 325 326 150 164
  148.   169 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
  149.   342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
  150.   358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
  151.   374 375 376 377 378
  152. .packtomark
  153.  
  154. % ExpertSubset
  155. mark
  156.   0
  157.   1 231 232 235 236 237 238 13 14 15 99 239 240 241 242 243
  158.   244 245 246 247 248 27 28 249 250 251 253 254 255 256 257 258
  159.   259 260 261 262 263 264 265 266 109 110 267 268 269 270 272 300
  160.   301 302 305 314 315 158 155 163 320 321 322 323 324 325 326 150
  161.   164 169 327 328 329 330 331 332 333 334 335 336 337 338 339 340
  162.   341 342 343 344 345 346
  163. .packtomark
  164.  
  165. ] readonly def
  166.  
  167. % ---------------- Font loading ---------------- %
  168.  
  169. % ------ Utilities ------ %
  170.  
  171. /advance {    % <n> advance -
  172.   f cff eq { pos add /pos exch store } { pop } ifelse
  173. } bind def
  174. /next {        % - next <byte>
  175.   f read {
  176.     1 advance
  177.     DEBUG { (  ) print dup = } if
  178.   } if
  179. } bind def
  180. /next2 {    % - next2 <byte1> <byte2>
  181.   f read {
  182.     f read {
  183.       2 advance
  184.       DEBUG { (  ) print 1 index =only (,) print dup = } if
  185.     } {
  186.       1 advance
  187.       DEBUG { (  ) print dup = } if
  188.     } ifelse
  189.   } if
  190. } bind def
  191. /nextstring {    % <length> nextstring <string>
  192.   dup 0 eq {
  193.     pop ()
  194.   } {
  195.     string f exch readstring pop dup length advance
  196.     DEBUG { (  ) print dup == } if
  197.   } ifelse
  198. } bind def
  199. /card8        % - card8 <card8>
  200.  /next load
  201. def
  202. /card16 {    % - card16 <card16>
  203.   next2 exch 8 bitshift add
  204. } bind def
  205. /card32 {    % - card32 <card32>
  206.   card16 16 bitshift card16 add
  207. } bind def
  208. /offsetprocs [
  209.   /card8 load
  210.   /card16 load
  211.   { card8 16 bitshift card16 add } bind
  212.   /card32 load
  213. ] readonly def
  214. /offsetproc {    % <offsize> offsetproc <proc>
  215.   1 sub //offsetprocs exch get
  216. } bind def
  217. /offset {    % <offsize> offset <offset>
  218.   offsetproc exec
  219. } bind def
  220. /sid        % - <sid> sid
  221.   /card16 load
  222. def
  223. /Index {    % - Index <array>
  224.   mark card16 dup 0 ne {
  225.     1 exch next offsetproc dup exec pop exch {
  226.       dup exec dup 4 -1 roll sub 3 1 roll exch
  227.     } repeat pop
  228.   } if pop .packtomark
  229.   [ exch { nextstring } forall ] readonly
  230. } bind def
  231. /tokens {    % - tokens <num1> ... <op#> (op# = 12 means EOF)
  232.   {
  233.     f read not { 12 exit } if
  234.     DEBUG { (..) print dup = } if
  235.     1 advance
  236.     dup 12 eq { pop next 32 add exit } if
  237.     dup 28 lt { exit } if
  238.     dup 32 lt {
  239.       28 sub {
  240.     { card16 32768 xor 32768 sub }
  241.     { 4 offset dup 16#7fffffff gt { -1 32 bitshift add } if }
  242.     { tokenreal }
  243.     { 31 exit }
  244.       } exch get exec
  245.     } {
  246.       dup 247 lt {
  247.     139 sub
  248.       } {
  249.     247 sub {
  250.       { next 108 add }
  251.       { next 364 add }
  252.       { next 620 add }
  253.       { next 876 add }
  254.       { next 108 add neg }
  255.       { next 364 add neg }
  256.       { next 620 add neg }
  257.       { next 876 add neg }
  258.       % 255 is deliberately omitted and will cause a rangecheck
  259.     } exch get exec
  260.       } ifelse
  261.     } ifelse
  262.   } loop
  263. } bind def
  264. /tokenbuf 100 string def
  265. /tokenput {    % <index> <char> tokenput <index+1>
  266.   tokenbuf 2 index 3 -1 roll put 1 add
  267. } bind def
  268. /tokenrealarray [
  269.  (0123456789.E) { } forall
  270.  [(E) 0 get /tokenput cvx (-) 0 get] cvx
  271.  null        % will give an error
  272.  (-) 0 get
  273.  { exit }
  274. ] readonly def
  275. /tokenreal {    % - tokenreal <float>
  276.   0 {
  277.     next exch 1 index -4 bitshift tokenrealarray exch get exec tokenput
  278.         % We must leave the byte on the stack temporarily so that
  279.         % the exit will see a consistent stack state.
  280.     1 index 15 and tokenrealarray exch get exec tokenput exch pop
  281.   } loop
  282.   tokenbuf 0 3 -1 roll getinterval cvr exch pop
  283. } bind def
  284. /Dict {        % <opsdict> Dict -
  285.   /opdict exch store {
  286.     mark tokens
  287.     DEBUG { (tokens: ) print ] dup === mark exch aload pop } if
  288.     opdict exch .knownget { exec } if cleartomark
  289.   } loop cleartomark
  290. } bind def
  291. /idstring {    % <sid> idstring <string|name>
  292.   dup 391 lt { //StandardStrings } { 391 sub strings } ifelse exch get
  293. } bind def
  294. /idname {    % <sid> idname <name>
  295.   idstring dup type /nametype ne { cvn } if
  296. } bind def
  297. /subfilefilter {    % <file> <length> subfilefilter <filter>
  298.     % SubFileDecode interprets a length of 0 as infinite.
  299.   dup 0 le { pop pop () 0 } if () /SubFileDecode filter
  300. } bind def
  301.  
  302. % ------ Top dictionary ------ %
  303.  
  304. /offput {    % <offset> <proc> offput -
  305.   DEBUG { (queued: ) print 1 index =only ( ) print dup === } if
  306.   currentdict exch aload length 1 add packedarray cvx
  307.   offsets 3 1 roll put
  308. } bind def
  309. /queueput {    % <font> <proc> queueput -
  310.   16#7fffffff offsets { pop .min } forall
  311.   pos sub nextstring
  312.   3 1 roll aload length 2 add packedarray cvx
  313.   [ queued aload pop counttomark 2 add -1 roll ]
  314.   /queued exch store
  315. } bind def
  316. /xxput {    % <value> <key> <dict> xxput -
  317.   3 1 roll exch put
  318. } bind def
  319. /putfi {    % <value> <key> putfi -
  320.   FontInfo xxput
  321. } bind def
  322. /xdef {        % <value> <key> xdef -
  323.   exch def
  324. } bind def
  325. /topdictops mark
  326.   12 { exit }
  327.   0 { idstring /version putfi }
  328.   1 { idstring /Notice putfi }
  329.   32 { idstring /Copyright putfi }
  330.   2 { idstring /FullName putfi }
  331.   3 { idstring /FamilyName putfi }
  332.   4 { idstring /Weight putfi }
  333.   33 { 0 ne /isFixedPitch putfi }
  334.   34 { /ItalicAngle putfi }
  335.   35 { /UnderlinePosition putfi }
  336.   36 { /UnderlineThickness putfi }
  337.   37 { /PaintType xdef }
  338.   38 { /FontType xdef }        % actually CharstringType
  339.   39 { counttomark array astore /FontMatrix xdef }
  340.   13 { /UniqueID xdef }
  341.   5 { counttomark array astore /FontBBox xdef }
  342.   40 { /StrokeWidth xdef }
  343.   14 { counttomark array astore /XUID xdef }
  344.   15 {
  345.     dup StandardCharsets length lt {
  346.       StandardCharsets exch get /charset xdef
  347.     } {
  348.       { queuecharset } offput
  349.     } ifelse
  350.   }
  351.   16 {
  352.     dup StandardEncodings length lt {
  353.       /Encoding xdef
  354.     } {
  355.       { queueEncoding } offput
  356.     } ifelse
  357.   }
  358.   17 { { readCharStrings } offput }
  359.   18 { exch /readPrivate cvx 2 packedarray offput }
  360.     % CIDFont operators
  361.   62 {        % ROS, must be first in a CIDFont
  362.     currentdict /FontType undef
  363.     currentdict /Private undef
  364.     currentdict /Encoding undef
  365.     currentdict /FontMatrix undef
  366.     /CIDFontVersion 0 def
  367.     /CIDFontRevision 0 def
  368.     /CIDFontType 0 def
  369.     /CIDCount 8720 def
  370.     3 dict begin
  371.     /Supplement xdef
  372.     idstring /Ordering xdef
  373.     idstring /Registry xdef
  374.     /CIDSystemInfo currentdict end def
  375.   }
  376.   63 { /CIDFontVersion xdef }
  377.   64 { /CIDFontRevision xdef }
  378.   65 { /CIDFontType xdef }
  379.   66 { /CIDCount xdef }
  380.   67 { /UIDBase xdef }
  381.   68 { { readFDArray } offput }
  382.   69 { { readFDSelect } offput }
  383.     % This operator only appears in a FDArray element.
  384.   70 { idstring /FontName exch def }
  385. .dicttomark readonly def
  386.  
  387. % readcharset and readFDSelect may require the length of CharStringArray,
  388. % but these structures may occur in the file before the CharStrings.
  389. % If that happens, use a hack: assume that all the data up to the next
  390. % queued read should be read.
  391.  
  392. /charstringcount {    % <font> charstringcount <count> true
  393.             % <font> charstringcount <length> false
  394.   /CharStringArray .knownget {
  395.     length true
  396.   } {
  397.     % Hack: look for the next queued read.
  398.     16#7fffffff offsets { pop .min } forall
  399.     pos sub false
  400.   } ifelse
  401. } bind def
  402.  
  403. /readCharStrings {    % <font> readCharStrings -
  404.   /CharStringArray Index put
  405. } bind def
  406.  
  407. % ------ Charsets and encodings ------ %
  408.  
  409. % Note: formats 1 and 2 can overflow the operand stack.
  410. % We'll fix this if it ever becomes necessary.
  411. /charsetcount {
  412.   charstringcount { 1 sub } { 2 idiv } ifelse
  413. } bind def
  414. /charsetformats [
  415. { [ 0 3 -1 roll charsetcount { sid } repeat ]
  416. } bind
  417. { [ 0 3 -1 roll charsetcount {
  418.     dup 0 eq { pop exit } if
  419.     sid card8 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
  420.   } loop ]
  421. } bind
  422. { [ 0 3 -1 roll charsetcount {
  423.     dup 0 eq { pop exit } if
  424.     sid card16 1 add 2 index .min { exch 1 sub 1 index 1 add } repeat pop
  425.   } loop ]
  426. } bind
  427. ] readonly def
  428. /queuecharset {        % <font> queuecharset -
  429.   { readcharset } queueput
  430. } bind def
  431. /readcharset {        % <data> <font> readcharset -
  432.   begin 0 () /SubFileDecode filter /f exch store
  433.   charsetformats next get currentdict exch exec /charset exch def end
  434. } bind def
  435.  
  436. /encodingformats [
  437. { 1 1 next { next exch Encoding 3 1 roll put } for
  438. } bind
  439. { 1 next {
  440.     next next 1 add {
  441.             % Stack: gid code
  442.       Encoding 1 index 3 index put
  443.       exch 1 add exch 1 add
  444.     } repeat pop
  445.   } repeat pop
  446. } bind
  447. ] readonly def
  448. /queueEncoding {    % <font> queueEncoding -
  449.   { readEncoding } queueput
  450. } bind def
  451. /readEncoding {        % <data> <font> readEncoding -
  452.   begin 0 () /SubFileDecode filter /f exch store
  453.   /Encoding [ 256 { /.notdef } repeat ] def
  454.   next encodingformats 1 index 127 and get exec
  455.   128 ge {
  456.             % Read supplementary encodings.
  457.     next {
  458.       Encoding next sid idname put
  459.     } repeat
  460.   } if end
  461. } bind def
  462.  
  463. % ------ FDArray and FDSelect ------ %
  464.  
  465. /readFDArray {        % <font> readFDArray -
  466.   Index exch
  467.   2 dict begin /f null def begin
  468.   [ exch {
  469.     dup length subfilefilter /f exch store
  470.     10 dict begin
  471.     /FontType 2 def
  472.     /PaintType 0 def
  473.     /FontMatrix [0.001 0 0 0.001 0 0] def
  474.     /Private 20 dict def
  475.     //topdictops Dict currentdict end
  476.   } forall ] /FDArray xdef end end
  477. } bind def
  478.  
  479. % Note: this implementation can overflow the operand stack.
  480. % We'll fix this if it ever becomes necessary.
  481. /fdselectformats [
  482. { [ exch charstringcount pop { card8 } repeat ] } bind
  483. { /FDSelect cvx /invalidfont signalerror } bind
  484. dup
  485. { pop [ card16 card16 exch {
  486.         % Stack: previndex
  487.     card8 card16 dup 4 1 roll 3 -1 roll sub 1 sub {
  488.       exch 1 index
  489.     } repeat exch
  490.   } repeat pop ]
  491. } bind
  492. ] readonly def
  493.  
  494. /readFDSelect {        % <font> readFDSelect -
  495.   begin fdselectformats next get currentdict exch exec /FDSelect exch def end
  496. } bind def
  497.  
  498.  
  499. % ------ Private dictionary ------ %
  500.  
  501. /deltarray {        % -mark- <num1> ... deltarray <num1'> ...
  502.   0 counttomark 1 sub { counttomark -1 roll add dup } repeat pop
  503.   counttomark array astore
  504. } bind def
  505.  
  506. /privatedictops mark
  507.   12 { exit }
  508.   6 { deltarray /BlueValues xdef }
  509.   7 { deltarray /OtherBlues xdef }
  510.   8 { deltarray /FamilyBlues xdef }
  511.   9 { deltarray /FamilyOtherBlues xdef }
  512.   41 { /BlueScale xdef }
  513.   42 { /BlueShift xdef }
  514.   43 { /BlueFuzz xdef }
  515.   10 { 1 array astore /StdHW xdef }
  516.   11 { 1 array astore /StdVW xdef }
  517.   44 { deltarray /StemSnapH xdef }
  518.   45 { deltarray /StemSnapV xdef }
  519.   46 { 0 ne /ForceBold xdef }
  520.   47 { /ForceBoldThreshold xdef }
  521.   48 { /lenIV xdef }
  522.   49 { /LanguageGroup xdef }
  523.   50 { /ExpansionFactor xdef }
  524.   51 { /initialRandomSeed xdef }
  525.   19 { PrivateStart add { readSubrs } offput }
  526.   20 { /defaultWidthX xdef }
  527.   21 { /nominalWidthX xdef }
  528.     % Multiple Master fonts only
  529.   59 { /NDV xdef }
  530.   60 { /CDV xdef }
  531.   61 { /lenBuildCharArray xdef }
  532. .dicttomark readonly def
  533.  
  534. /readPrivate {        % <font> <size> readPrivate -
  535.   2 dict begin
  536.   /PrivateStart pos def
  537.   f 3 1 roll exch 1 index f exch subfilefilter /f exch store
  538.   dup /FontType get exch
  539.   /Private get begin
  540.         % Default lenIV to -1 even for Type 1 CharStrings.
  541.   2 ne { /lenIV -1 def } if
  542.   //privatedictops Dict end
  543.   exch /f exch store advance
  544.   end
  545. } bind def
  546.  
  547. /readSubrs {        % <font> readSubrs -
  548.   /Subrs Index put
  549. } bind def
  550.  
  551. % ------ Main program ------ %
  552.  
  553. % Clean up after finishing a font.
  554. /cleanupFont {        % (currentdict) cleanupFont -
  555.         % Remove unwanted entries.
  556.   currentdict /charset undef
  557.   currentdict /CharStringArray undef
  558. } bind def
  559.  
  560. % Update the Encoding and CharStrings for a real font.
  561. /finishFont {        % (currentdict) finishFont -
  562.         % Construct the real Encoding.
  563.         % The value of Encoding is either a number, for predefined
  564.         % encodings, or an array of mixed GIDs and names.
  565.   /Encoding mark Encoding
  566.   DEBUG { (Encoding: ) print dup === flush } if
  567.   dup type /integertype eq {
  568.     StandardEncodings exch get { idname } forall
  569.   } {
  570.     {
  571.       dup type /integertype eq { charset exch get idname } if
  572.     } forall
  573.   } ifelse .packtomark def
  574.         % Construct the CharStrings.
  575.         % Note that they may only correspond to an initial
  576.         % subset of the charset.
  577.   /CharStrings charset length CharStringArray length .min dict def
  578.   DEBUG {
  579.     charset length =only ( charset ) print
  580.     CharStringArray length =only ( CharStringArray) =
  581.     charset == flush
  582.   } if
  583.   0 1 CharStrings maxlength 1 sub {
  584.     dup CharStringArray exch get
  585.     exch charset exch get idstring CharStrings xxput
  586.   } for
  587.   cleanupFont
  588. } bind def
  589.  
  590. % Replace CharStrings with GlyphDirectory for a CIDFont.
  591. /finishCIDFont {    % (currentdict) finishCIDFont -
  592.         % Construct the GlyphDirectory, similar to CharStrings.
  593.   /FDBytes FDArray length 1 gt { 1 } { 0 } ifelse def
  594.   /GlyphDirectory charset length CharStringArray length .min dict def
  595.   DEBUG {
  596.     charset length =only ( charset ) print
  597.     CharStringArray length =only ( CharStringArray) =
  598.     charset == flush
  599.   } if
  600.   0 1 GlyphDirectory maxlength 1 sub {
  601.     dup CharStringArray exch get
  602.         % If there is more than one FDArray entry, add the font
  603.         % index to the beginning of each charstring.
  604.     FDBytes 1 eq {
  605.       FDSelect 2 index get
  606.       1 string dup 0 4 -1 roll put exch concatstrings
  607.     } if
  608.     exch charset exch get GlyphDirectory xxput
  609.   } for
  610.         % Clean up.
  611.   currentdict /FDSelect undef
  612.   cleanupFont
  613. } bind def
  614. % We need to pass the file as a parameter for the sake of the PDF
  615. % interpreter. Also for the sake of PDF, a flag forces the font
  616. % to be defined as <resname> instead of the name embedded in the data.
  617. % This is needed for subsetted fonts; it is valid if the CFF
  618. % contains only a single font.
  619. /StartData {          % <resname> <nbytes> StartData -
  620.   currentfile exch subfilefilter false ReadData
  621. } bind def
  622. /ReadData {           % <resname> <file> <forceresname> ReadData -
  623.  
  624.     % Initialize.
  625.  
  626.   30 dict begin
  627.   /forceresname exch def
  628.   /cff exch def
  629.   /pos 0 def
  630.   /resname exch cvlit def
  631.   /DEBUG DEBUG def    % bring the binding closer
  632.  
  633.     % Read the header.
  634.  
  635.   /f cff def
  636.   /vmajor next def
  637.   /vminor next def
  638.   /hdrsize next def
  639.   /aoffsize next def
  640.  
  641.     % Read the Indexes.
  642.  
  643.   /names Index def
  644.   /topdicts Index def
  645.   /strings Index def
  646.   /gsubrs Index def
  647.  
  648.     % Read the top Dicts.
  649.  
  650.   /offsets 50 dict def
  651.   /queued [] def
  652.   /opdict null def        % reserve a slot
  653.   /fonts [ topdicts {
  654.     0 () /SubFileDecode filter /f exch def
  655.     40 dict begin
  656.         % Preload defaults that differ from PostScript defaults,
  657.         % or that are required.
  658.       /FontType 2 def
  659.       /PaintType 0 def
  660.       /FontMatrix [0.001 0 0 0.001 0 0] def
  661.       /charset StandardCharsets 0 get def
  662.       /Encoding 0 def
  663.       /FontInfo 10 dict
  664.     dup /UnderlinePosition -100 put
  665.     dup /UnderlineThickness 50 put
  666.       def
  667.       /Private 20 dict
  668.     gsubrs length 0 ne { dup /GlobalSubrs gsubrs put } if
  669.       def
  670.       //topdictops Dict
  671.     currentdict end
  672.   } forall ] def
  673.  
  674.     % Read other tables with queued offsets.
  675.  
  676.   DEBUG { (offsets: ) print [ offsets { pop } forall ] == } if
  677.   { /f cff def
  678.     DEBUG { (pos=) print pos = } if
  679.     offsets pos 2 copy .knownget not { pop pop exit } if
  680.     3 1 roll undef
  681.     DEBUG { (exec queued: ) print dup == } if
  682.     exec
  683.   } loop
  684.   offsets length 0 ne {
  685.     (Error: missing tables at ) print [ offsets { pop } forall ] ==
  686.     (Current position is ) print pos ==
  687.     flush stop
  688.   } if
  689.  
  690.     % Process out-of-order tables.
  691.  
  692.   DEBUG { queued length =only ( queued) = flush } if
  693.   queued { exec } forall
  694.  
  695.     % Update Encoding and CharStrings.
  696.  
  697.   fonts {
  698.     begin
  699.     currentdict /CIDFontType known { finishCIDFont } { finishFont } ifelse
  700.     end
  701.   } forall
  702.  
  703.     % Wrap up.
  704.  
  705.   resname mark 0 1 fonts length 1 sub {
  706.     DEBUG { dup =only ( ) print flush } if
  707.     dup names exch get
  708.     forceresname { pop resname } if
  709.     DEBUG { dup == flush } if
  710.     exch fonts exch get
  711.     dup /CIDFontType known {
  712.         % This is a CIDFont.
  713.       dup /CIDFontName 3 index put
  714.       1 index exch /CIDFont defineresource
  715.     } {
  716.         % This is a font.
  717.       dup /FontName 3 index put
  718.       1 index exch definefont
  719.     } ifelse
  720.   } for .dicttomark
  721.   end        % temporary dict
  722.   end        % FontSetInit ProcSet
  723.   /FontSet defineresource pop
  724.  
  725. } bind def
  726.  
  727. % ---------------- Resource category definition ---------------- %
  728.  
  729. currentdict end readonly
  730.  
  731. languagelevel exch 2 .setlanguagelevel
  732.  
  733. /FontSet /Generic /Category findresource dup length dict .copydict
  734. /Category defineresource pop
  735.  
  736. /FontSetInit exch /ProcSet defineresource pop
  737.  
  738. .setlanguagelevel
  739.